package cn.demoncat.util.mybatis.base;

import cn.demoncat.util.lang.entity.Result;
import cn.demoncat.util.mybatis.entity.Pager;

import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Function;

/**
 * BaseService
 * 
 * @author 延晓磊
 *
 * @since 2016年3月16日
 */
public interface BaseService<T extends BaseEntity<T, P>, P extends Serializable> {

	/**
	 * 添加
	 * 
	 * 1、如果属性为null，将赋值字段为null或报错cannot be null，不会使用数据库默认值；建议在程序中赋默认值
	 * 2、如果赋值ID，使用自定义ID；如果ID为null，使用数据库自增
	 * 3、更新后可以通过o.getId()获取主键 
	 * 4、如果使用INSERT INTO，插入失败时抛异常；如果使用INSERT IGNORE INTO，成功返回1，失败返回0
	 * 
	 * @param o
	 * 
	 * @return 插入的记录数
	 */
	int save(T o);

	/**
	 * 批量添加
	 * 
	 * 1、如果属性为null，将赋值字段为null或报错cannot be null，不会使用数据库默认值；建议在程序中赋默认值
	 * 2、如果赋值ID，使用自定义ID；如果ID为null，使用数据库自增 
	 * 3、更新后可以通过o.getId()获取主键 
	 * 4、如果使用INSERT INTO，插入失败时抛异常；如果使用INSERT IGNORE INTO，成功返回1，失败返回0
	 * 
	 * @param os
	 * 
	 * @return 插入的记录数
	 */
	int batchSave(List<T> os);

	/**
	 * 根据ID删除
	 * 
	 * @param id
	 * @return 删除的记录数
	 */
	int delete(P id);

	/**
	 * 根据ID删除
	 *
	 * @param id
	 * @return 删除的数据，数据不存在/删除失败返回null
	 */
	T deleteAndGet(P id);

	/**
	 * 
	 * 根据ID+条件删除
	 *
	 * @param id
	 * @param condition
	 * @return 删除的记录数
	 * 
	 * @author 延晓磊
	 */
	int delete(P id, Map<String, Object> condition);

	/**
	 * 安全删除
	 * 
	 * @param id
	 * @param createUser
	 * @return 删除的记录数
	 */
	int delete(P id, Long createUser);

	/**
	 * 
	 * 安全ID+条件删除
	 *
	 * @param id
	 * @param createUser
	 * @param condition
	 * 
	 * @return 删除的记录数
	 * 
	 * @author 延晓磊
	 */
	int delete(P id, Long createUser, Map<String, Object> condition);

	/**
	 * 假删除(修改isDel字段)
	 * 
	 * @param id
	 * @return 删除的记录数
	 */
	int deleteFake(P id);

	/**
	 * 
	 * ID+条件假删除
	 *
	 * @param id
	 * @param condition
	 * @return 删除的记录数
	 * 
	 * @author 延晓磊
	 */
	int deleteFake(P id, Map<String, Object> condition);

	/**
	 * 安全假删除(修改isDel字段)
	 * 
	 * @param id
	 * @param createUser
	 * @return 删除的记录数
	 */
	int deleteFake(P id, Long createUser);

	/**
	 * 
	 * 安全ID+条件假删除
	 *
	 * @param id
	 * @param createUser
	 * @param condition
	 * @return 删除的记录数
	 * 
	 * @author 延晓磊
	 */
	int deleteFake(P id, Long createUser, Map<String, Object> condition);

	/**
	 * 批量条件删除
	 * 
	 * @param ids
	 * @return 删除的记录数
	 */
	int batchDelete(Collection<P> ids);
	
	/**
	 * 批量条件删除
	 * 
	 * @param condition
	 * @return 删除的记录数
	 */
	int batchDelete(Map<String, Object> condition);
	
	/**
	 * 批量条件删除
	 * 
	 * @param ids
	 * @param condition
	 * @return 删除的记录数
	 */
	int batchDelete(Collection<P> ids, Map<String, Object> condition);

	/**
	 * 安全批量条件删除
	 *
	 * @param createUser
	 * @param ids
	 *
	 * @return 删除的记录数
	 */
	int batchDelete(Long createUser, Collection<P> ids);

	/**
	 * 安全批量条件删除
	 * 
	 * @param createUser
	 * @param ids
	 * @param condition
	 * 
	 * @return 删除的记录数
	 */
	int batchDelete(Long createUser, Collection<P> ids, Map<String, Object> condition);

	/**
	 * 批量条件假删除
	 * 
	 * @param ids
	 * @param condition
	 * @return 删除的记录数
	 */
	int batchDeleteFake(Collection<P> ids, Map<String, Object> condition);
	
	/**
	 * 批量条件假删除
	 * 
	 * @param condition
	 * @return 删除的记录数
	 */
	int batchDeleteFake(Map<String, Object> condition);

	/**
	 * 安全批量条件假删除
	 * 
	 * @param createUser
	 * @param ids
	 * @param condition
	 * @return 删除的记录数
	 */
	int batchDeleteFake(Long createUser, Collection<P> ids, Map<String, Object> condition);
	
	/**
	 * 安全批量条件假删除
	 * 
	 * @param createUser
	 * @param condition
	 * @return 删除的记录数
	 */
	int batchDeleteFake(Long createUser, Map<String, Object> condition);

	/**
	 * 更新
	 * 
	 * 1、排除null属性的字段
	 * 2、如果o或id为null，抛异常
	 * 
	 * @param o
	 * @return 更新的记录数
	 */
	int update(T o);
	
	/**
	 * 完整更新
	 * 
	 * 1、不排除null属性的字段
	 * 2、如果o或id为null，抛异常
	 * 
	 * @param o
	 * @return 更新的记录数
	 */
	int fullUpdate(T o);

	/**
	 * 乐观锁更新(根据version字段进行CAS更新)
	 * 
	 * 1、设置事务为READ_COMMITTED，方便重试时可重复读取数据
	 * 2、调用本方法
	 * 3、循环无数次，查询数据、通过task修改数据、以version为条件更新，超次数未更新成功时抛异常：BizRuntimeException.BUSY
	 * 
	 * @param id	ID查询
	 * @param task	对查询到的数据进行更新（修改对象的属性，变更引用无效）
	 * 
	 * @return 更新结果数据
	 */
	T update(P id, Consumer<T> task);
	
	/**
	 * 乐观锁更新(根据version字段进行CAS更新)
	 * 
	 * 1、设置事务为READ_COMMITTED，方便重试时可重复读取数据
	 * 2、调用本方法
	 * 3、循环times次，查询数据、通过task修改数据、以version为条件更新，超次数未更新成功时抛异常：BizRuntimeException.BUSY
	 * 
	 * @param id	ID查询。未找到将抛异常
	 * @param task	对查询到的数据进行更新（修改对象的属性，变更引用无效）
	 * @param times	重试次数（默认MapperConstant.REPEAT_LOCK次）
	 * 
	 * @return 更新结果数据
	 */
	T update(P id, Consumer<T> task, int times);
	
	/**
	 * 条件更新
	 * 
	 * 1、排除null属性的字段
	 * 2、如果o为null，抛异常
	 * 3、如果o.id为null，将更新condition匹配的所有数据；如果o.id非null，将判断id对应的数据是否满足condition
	 * 
	 * @param o  
	 * @param condition
	 * @return 更新的记录数
	 */
	int update(T o, Map<String, Object> condition);
	
	/**
	 * 完整条件更新
	 * 
	 * 1、不排除null属性的字段
	 * 2、如果o为null，抛异常
	 * 3、如果o.id为null，将更新condition匹配的所有数据；如果o.id非null，将判断id对应的数据是否满足condition
	 * 
	 * @param o  
	 * @param condition
	 * @return 更新的记录数
	 */
	int fullUpdate(T o, Map<String, Object> condition);

	/**
	 * 批量更新
	 * 
	 * 1、排除null属性的字段
	 * 2、如果o为null，抛异常
	 * 3、如果o.id为null，将更新ids数据
	 * 
	 * @param o  
	 * @param ids 要更新的数据集
	 * 
	 * @return 更新的记录数
	 */
	int update(T o, Collection<P> ids);
	
	/**
	 * 批量条件更新
	 * 
	 * 1、排除null属性的字段
	 * 2、如果o为null，抛异常
	 * 3、如果o.id为null，将更新ids数据，并筛选condition条件
	 * 
	 * @param o  
	 * @param condition
	 * @param ids 要更新的数据集
	 * 
	 * @return 更新的记录数
	 */
	int update(T o, Map<String, Object> condition, Collection<P> ids);
	
	/**
	 * 安全更新
	 * 
	 * @param o
	 * @param createUser
	 * @return 更新的记录数
	 */
	int update(T o, Long createUser);

	/**
	 * 安全条件更新
	 * 
	 * @param o
	 * @param createUser
	 * @param condition
	 * @return 更新的记录数
	 */
	int update(T o, Long createUser, Map<String, Object> condition);

	/**
	 * 批量更新
	 * 
	 * 1、排除null属性的字段
	 * 2、如果os为null，抛异常
	 * 
	 * @param os
	 */
	void batchUpdate(List<T> os);

	/**
	 * 完整批量更新
	 * 
	 * 1、不排除null属性的字段
	 * 2、如果os为null，抛异常
	 * 
	 * @param os
	 */
	void batchFullUpdate(List<T> os);
	
	/**
	 * 批量条件更新
	 * 
	 * 1、排除null属性的字段
	 * 
	 * @param os
	 * @param condition
	 */
	void batchUpdate(List<T> os, Map<String, Object> condition);
	
	/**
	 * 完整批量条件更新
	 * 
	 * 1、不排除null属性的字段
	 * 
	 * @param os
	 * @param condition
	 */
	void batchFullUpdate(List<T> os, Map<String, Object> condition);

	/**
	 * 安全批量更新
	 * 
	 * @param os
	 * @param createUser
	 */
	void batchUpdate(List<T> os, Long createUser);

	/**
	 * 
	 * 安全批量条件更新
	 * 
	 * @param os
	 * @param condition
	 * @param createUser
	 */
	void batchUpdate(List<T> os, Long createUser, Map<String, Object> condition);

	/**
	 * 更新字段
	 * 
	 * @param id
	 * @param fields 字段Map
	 *            
	 * @return 更新的记录数
	 */
	int updateFields(P id, Map<String, Object> fields);
	
	/**
	 * 批量条件更新字段
	 * 
	 * @param fields
	 *            字段Map
	 * @param condition
	 *            修改条件
	 * @param ids
	 *            修改的IDS
	 * @return 更新的记录数
	 */
	int updateFields(Map<String, Object> fields, Map<String, Object> condition, Collection<P> ids);

	/**
	 * 安全批量条件更新字段
	 *
	 * @param fields
	 *            字段Map
	 * @param createUser
	 * @param ids
	 *            修改的IDS
	 * @return 更新的记录数
	 */
	int updateFields(Map<String, Object> fields, Long createUser, Collection<P> ids);

	/**
	 * 安全批量条件更新字段
	 * 
	 * @param fields
	 *            字段Map
	 * @param createUser
	 * @param condition
	 *            修改条件
	 * @param ids
	 *            修改的IDS
	 * @return 更新的记录数
	 */
	int updateFields(Map<String, Object> fields, Long createUser, Map<String, Object> condition, Collection<P> ids);

	/**
	 * 批量条件更新字段
	 * 
	 * @param fields
	 *            字段Map
	 * @param condition
	 *            修改条件
	 * @return 更新的记录数
	 */
	int updateFields(Map<String, Object> fields, Map<String, Object> condition);
	
	/**
	 * 安全批量条件更新字段
	 * 
	 * @param fields
	 *            字段Map
	 * @param createUser
	 * @param condition
	 *            修改条件
	 * @return 更新的记录数
	 */
	int updateFields(Map<String, Object> fields, Long createUser, Map<String, Object> condition);
	
	/**
	 * 批量条件更新字段
	 * 
	 * @param fields
	 *            字段Map
	 * @param ids
	 *            修改的IDS
	 * @return 更新的记录数
	 */
	int updateFields(Map<String, Object> fields, Collection<P> ids);
	
	/**
	 * 排序
	 * 
	 * @param id 数据的ID
	 * @param sort 数据的排序
	 * @return 更新的记录数(1表示正常)
	 */
	int updateSort(P id, Long sort);

	/**
	 * 安全排序
	 * 
	 * @param id  数据的ID
	 * @param sort  数据的排序
	 * @param createUser
	 * @return 更新的记录数(1表示正常)
	 */
	int updateSort(P id, Long sort, Long createUser);

	/**
	 * 条件排序
	 * 
	 * @param id 数据的ID
	 * @param sort 数据的排序
	 * @param condition
	 * @return 更新的记录数(1表示正常)
	 */
	int updateSort(P id, Long sort, Map<String, Object> condition);
	
	/**
	 * 排序
	 * 
	 * @param id 数据的ID
	 * @param sort 数据的排序
	 * @param updateUser 更新人
	 * @param updateTime 更新时间
	 * @return 更新的记录数(1表示正常)
	 */
	int updateSort(P id, Long sort, Long updateUser, LocalDateTime updateTime);

	/**
	 * 安全排序
	 * 
	 * @param id 数据的ID
	 * @param sort 数据的排序
	 * @param createUser
	 * @param updateUser 更新人
	 * @param updateTime 更新时间
	 * @return 更新的记录数(1表示正常)
	 */
	int updateSort(P id, Long sort, Long createUser, Long updateUser, LocalDateTime updateTime);
	
	/**
	 * 条件排序
	 * 
	 * @param id 数据的ID
	 * @param sort 数据的排序
	 * @param updateUser 更新人
	 * @param updateTime 更新时间
	 * @param condition
	 * @return 更新的记录数(1表示正常)
	 */
	int updateSort(P id, Long sort, Long updateUser, LocalDateTime updateTime, Map<String, Object> condition);
	
	/**
	 * 状态
	 * 
	 * @param id 数据的ID
	 * @param status 数据的状态
	 * @return 更新的记录数(1表示正常)
	 */
	int updateStatus(P id, String status);

	/**
	 * 安全状态
	 * 
	 * @param id  数据的ID
	 * @param status  数据的状态
	 * @param createUser
	 * @return 更新的记录数(1表示正常)
	 */
	int updateStatus(P id, String status, Long createUser);

	/**
	 * 条件状态
	 * 
	 * @param id 数据的ID
	 * @param status 数据的状态
	 * @param condition
	 * @return 更新的记录数(1表示正常)
	 */
	int updateStatus(P id, String status, Map<String, Object> condition);
	
	/**
	 * 状态
	 * 
	 * @param id 数据的ID
	 * @param status 数据的状态
	 * @param updateUser 更新人
	 * @param updateTime 更新时间
	 * @return 更新的记录数(1表示正常)
	 */
	int updateStatus(P id, String status, Long updateUser, LocalDateTime updateTime);

	/**
	 * 安全状态
	 * 
	 * @param id 数据的ID
	 * @param status 数据的状态
	 * @param createUser
	 * @param updateUser 更新人
	 * @param updateTime 更新时间
	 * @return 更新的记录数(1表示正常)
	 */
	int updateStatus(P id, String status, Long createUser, Long updateUser, LocalDateTime updateTime);
	
	/**
	 * 条件状态
	 * 
	 * @param id 数据的ID
	 * @param status 数据的状态
	 * @param updateUser 更新人
	 * @param updateTime 更新时间
	 * @param condition
	 * @return 更新的记录数(1表示正常)
	 */
	int updateStatus(P id, String status, Long updateUser, LocalDateTime updateTime, Map<String, Object> condition);
	
	/**
	 * 处理数据
	 * 
	 * @param id		ID
	 * @param handler	fn(原数据)
	 * @return
	 * 
	 * @author 延晓磊
	 *
	 * @since 2020年8月10日
	 */
	Result handler(P id, Function<T, Result> handler);
	
	/**
	 * 通过ID查询对象
	 * 
	 * @param id
	 * @return 对象
	 */
	T getById(P id);
	
	/**
	 * 通过ID查询对象(悲观锁)
	 * 
	 * @param id
	 * @return 单个对象
	 */
	T getForUpdate(P id);
	
	/**
	 * 通过ID查询对象
	 * 
	 * @param id
	 * @param createUser
	 * @return 对象
	 */
	T getById(P id,Long createUser);
	
	/**
	 * 通过ID查询对象
	 * 
	 * @param id
	 * @param createUser
	 * @param condition
	 * @return 对象
	 */
	T getById(P id,Long createUser,Map<String, Object> condition);
	
	/**
	 * 通过ID查询对象
	 * 
	 * @param id
	 * @param condition
	 * @return 对象
	 */
	T getById(P id,Map<String, Object> condition);

	/**
	 * 根据条件查询，返回唯一对象
	 * 
	 * @param condition
	 * @return 对象（以 limit 1 查询列表，不负责校验是否有多个）
	 */
	T getByCondition(Map<String, Object> condition);

	/**
	 * 根据条件查询，返回唯一对象
	 * 
	 * @param condition
	 * @param sortColumns
	 * 
	 * @return 对象（以 limit 1 查询列表，不负责校验是否有多个）
	 */
	T getByCondition(Map<String, Object> condition,String sortColumns);
	
	/**
	 * 根据查询条件和ids统计记录数
	 * 
	 * @param condition
	 * @param ids
	 * @return 记录数
	 */
	long countAll(Map<String, Object> condition, Collection<P> ids);

	/**
	 * 根据查询条件统计记录数
	 * 
	 * @param condition
	 * @return 记录数
	 */
	long countAll(Map<String, Object> condition);
	
	/**
	 * 根据ids统计记录数
	 * 
	 * @param ids
	 * @return 记录数
	 */
	long countAll(Collection<P> ids);
	
	/**
	 * 统计总记录数
	 * 
	 * @return 记录数
	 */
	long countAll();

	/**
	 * 判断是否存在
	 *
	 * @param id
	 * @return
	 */
    boolean exists(P id);

	/**
	 * 判断是否存在
	 *
	 * @param condition
	 * @return
	 */
	boolean exists(Map<String, Object> condition);

	/**
     * 全部查询 
     * 
     * @return 对象列表 
     */
	List<T> findAll();
	
	/**
     * 全部查询 
     * 
     * @param sortColumns  	排序方式 
     * @return 对象列表 
     */
	List<T> findAll(String sortColumns);
	
	/**
     * 全部分页查询 
     * 
     * @param pageNum		页码：null/0/负数 == 首页
	 * @param pageSize  	页长：null/0/负数 == 10，最大10000
     * @return 对象列表
     */
	List<T> findAll(Integer pageNum, Integer pageSize);
	
	/**
     * 全部分页查询 
     * 
     * @param pageNum		页码：null/0/负数 == 首页
	 * @param pageSize  	页长：null/0/负数 == 10，最大10000
     * @param sortColumns  	排序方式 
     * @return 对象列表
     */
	List<T> findAll(Integer pageNum, Integer pageSize,String sortColumns);
	
	/**
     * 根据ids查询 
     * 
     * @param ids			查询数据的id集
     * @return 对象列表 
     */
	List<T> findAll(Collection<P> ids);
	
	/**
     * 根据ids查询 
     * 
     * @param ids			查询数据的id集
     * @param sortColumns  	排序方式 
     * @return 对象列表 
     */
	List<T> findAll(Collection<P> ids, String sortColumns);
	
	/**
     * 根据条件查询 
     * 
     * @param condition		查询条件 (null表示全部) 
     * @return 对象列表 
     */
	List<T> findAll(Map<String, Object> condition);
	
	/**
     * 根据条件查询 
     * 
     * @param condition		查询条件 (null表示全部) 
     * @param sortColumns  	排序方式 
     * @return 对象列表
     */
	List<T> findAll(Map<String, Object> condition, String sortColumns);
	
	/**
     * 根据条件查询 
     * 
     * @param condition		查询条件 (null表示全部) 
	 * @param pageSize  	页长：null/0/负数 == 10，最大10000
     * @return 对象列表
     */
	List<T> findAll(Map<String, Object> condition,Integer pageSize);
 
	/**
     * 根据条件分页查询 
     * 
     * @param condition		查询条件 (null表示全部) 
     * @param pageNum		页码：null/0/负数 == 首页
	 * @param pageSize  	页长：null/0/负数 == 10，最大10000
     * @return 对象列表
     */
	List<T> findAll(Map<String, Object> condition, Integer pageNum, Integer pageSize);
	
	/**
     * 根据条件分页查询 
     * 
     * @param condition		查询条件 (null表示全部) 
     * @param pageNum		页码：null/0/负数 == 首页
	 * @param pageSize  	页长：null/0/负数 == 10，最大10000
     * @param sortColumns  	排序方式 
     * @return 对象列表
     */
	List<T> findAll(Map<String, Object> condition, Integer pageNum, Integer pageSize,String sortColumns);

	/**
     * 根据条件和ids分页查询 
     * 
     * @param condition		查询条件 (null表示全部) 
     * @param ids			查询数据的id集
     * @param pageNum		页码：null/0/负数 == 首页
	 * @param pageSize  	页长：null/0/负数 == 10，最大10000
     * @param sortColumns  	排序方式 
     * @return 对象列表
     */
	List<T> findAll(Map<String, Object> condition, Collection<P> ids, Integer pageNum, Integer pageSize,String sortColumns);
	
	/**
     * 全部分页查询，返回Pager
     * 
     * @param pageNum		页码：null/0 == 首页，负数 == 尾页，大于页数 == 尾页
	 * @param pageSize  	页长：null/0/负数 == 10，最大10000
     * @return 分页对象
     */
	Pager<T> findPage(Integer pageNum, Integer pageSize);
	
	/**
     * 根据条件分页查询，返回Pager
     * 
     * @param condition		查询条件 (null表示全部) 
     * @param pageNum		页码：null/0 == 首页，负数 == 尾页，大于页数 == 尾页
	 * @param pageSize  	页长：null/0/负数 == 10，最大10000
     * @return 分页对象
     */
	Pager<T> findPage(Map<String, Object> condition, Integer pageNum, Integer pageSize);
	
	/**
     * 根据条件分页查询，返回Pager
     * 
     * @param condition		查询条件 (null表示全部) 
     * @param pageNum		页码：null/0 == 首页，负数 == 尾页，大于页数 == 尾页
	 * @param pageSize  	页长：null/0/负数 == 10，最大10000
     * @param sortColumns  	排序方式 
     * @return 分页对象
     */
	Pager<T> findPage(Map<String, Object> condition, Integer pageNum, Integer pageSize, String sortColumns);
	
	/**
     * 分页排序查询，返回Pager
     * 
     * @param pageNum		页码：null/0 == 首页，负数 == 尾页，大于页数 == 尾页
	 * @param pageSize  	页长：null/0/负数 == 10，最大10000
     * @param sortColumns  	排序方式 
     * @return 分页对象
     */
	Pager<T> findPage(Integer pageNum, Integer pageSize, String sortColumns);
	
	/**
     * 根据条件和ids分页查询，返回Pager
     * 
     * @param condition		查询条件 (null表示全部) 
     * @param ids			查询数据的id集
     * @param pageNum		页码：null/0 == 首页，负数 == 尾页，大于页数 == 尾页
	 * @param pageSize  	页长：null/0/负数 == 10，最大10000
     * @param sortColumns  	排序方式 
     * @return 分页对象
     */
	Pager<T> findPage(Map<String, Object> condition, Collection<P> ids, Integer pageNum, Integer pageSize, String sortColumns);

	/**
     * 全部查询 
     * 
     * @return ID列表 
     */
	List<P> findIds();
	
	/**
     * 全部查询 
     * 
     * @param sortColumns  	排序方式 
     * @return ID列表 
     */
	List<P> findIds(String sortColumns);
	
	/**
     * 根据ids查询 
     * 
     * @param ids			查询数据的id集
     * @return ID列表 
     */
	List<P> findIds(Collection<P> ids);
	
	/**
     * 根据ids查询 
     * 
     * @param ids			查询数据的id集
     * @param sortColumns  	排序方式 
     * @return ID列表 
     */
	List<P> findIds(Collection<P> ids, String sortColumns);
	
	/**
     * 根据条件查询 
     * 
     * @param condition		查询条件 (null表示全部) 
     * @return ID列表 
     */
	List<P> findIds(Map<String, Object> condition);
	
	/**
     * 根据条件查询 
     * 
     * @param condition		查询条件 (null表示全部) 
     * @param sortColumns  	排序方式 
     * @return ID列表
     */
	List<P> findIds(Map<String, Object> condition, String sortColumns);
	
	/**
     * 根据条件和ids查询 
     * 
     * @param condition		查询条件 (null表示全部) 
     * @param ids			查询数据的id集
     * @return ID列表
     */
	List<P> findIds(Map<String, Object> condition, Collection<P> ids);
	
	/**
     * 根据条件和ids查询 
     * 
     * @param condition		查询条件 (null表示全部) 
     * @param ids			查询数据的id集
     * @param sortColumns  	排序方式 
     * @return ID列表
     */
	List<P> findIds(Map<String, Object> condition, Collection<P> ids, String sortColumns);

	/**
	 * 全部分页查询，返回Pager
	 *
	 * @param pageNum		页码：null/0 == 首页，负数 == 尾页，大于页数 == 尾页
	 * @param pageSize  	页长：null/0/负数 == 10，最大10000
	 * @return 分页对象
	 */
	Pager<P> findIdPage(Integer pageNum, Integer pageSize);

	/**
	 * 根据条件分页查询，返回Pager
	 *
	 * @param condition		查询条件 (null表示全部)
	 * @param pageNum		页码：null/0 == 首页，负数 == 尾页，大于页数 == 尾页
	 * @param pageSize  	页长：null/0/负数 == 10，最大10000
	 * @return 分页对象
	 */
	Pager<P> findIdPage(Map<String, Object> condition, Integer pageNum, Integer pageSize);

	/**
	 * 分页排序查询，返回Pager
	 *
	 * @param pageNum		页码：null/0 == 首页，负数 == 尾页，大于页数 == 尾页
	 * @param pageSize  	页长：null/0/负数 == 10，最大10000
	 * @param sortColumns  	排序方式
	 * @return 分页对象
	 */
	Pager<P> findIdPage(Integer pageNum, Integer pageSize, String sortColumns);

	/**
	 * 根据条件分页查询，返回Pager
	 *
	 * @param condition		查询条件 (null表示全部)
	 * @param pageNum		页码：null/0 == 首页，负数 == 尾页，大于页数 == 尾页
	 * @param pageSize  	页长：null/0/负数 == 10，最大10000
	 * @param sortColumns  	排序方式
	 * @return 分页对象
	 */
	Pager<P> findIdPage(Map<String, Object> condition, Integer pageNum, Integer pageSize, String sortColumns);

}
